一、面向对象与面向过程

1. 编程思想区分

• 面向过程：执行者思维，按步骤拆分，适合简单业务（C语言典型）。

• 面向对象：设计者思维，把事物抽象成类，封装属性和方法，适合大型复杂项目。

• 宏观面向对象做架构，微观方法内部仍是面向过程编码。

• Python一切皆对象：数字、字符串、函数、类全是对象。

2. 对象演化

零散数据 → 同类型数组 → C语言结构体 → 类+对象（属性+方法封装）

二、类与对象基础

1. 类&对象

• 类：抽象模板（大驼峰命名）；对象：类实例化的具体实体

class Student:
    pass
s = Student() #实例化

2. 构造方法 init

对象创建后自动调用，负责初始化属性，不创建对象（__new__创建对象），首参数固定self代表当前实例。

class Student:
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def say_score(self):
        print(f"{self.name}:{self.score}")
s1 = Student("张三",80)
s1.say_score()

3. 实例属性、实例方法

• 实例属性：绑定单个对象，self.属性定义，可动态添加对象.属性=值

• 实例方法：首参数self，对象.方法()调用

• 工具：dir(对象)查看成员、对象.__dict__查看属性字典、isinstance(对象,类)判断类型

三、类属性、类方法、静态方法

1. 类属性

定义在类内、方法外，全实例共享，类名.属性读写

class Student:
    company = "尚学堂"
    count = 0
    def __init__(self,name):
        self.name = name
        Student.count +=1

2. 类方法 @classmethod

@classmethod修饰，首参数cls指代类，只能访问类成员

@classmethod
def get_cnt(cls):
    print(cls.count)

3. 静态方法 @staticmethod

无默认参数，无法访问实例/类属性，等价普通函数

@staticmethod
def add(a,b):
    return a+b

四、析构方法 del

对象引用计数为0自动执行，del 实例手动触发，用于释放文件/网络资源

class Demo:
    def __del__(self):
        print("对象销毁")

五、__call__可调用对象

定义__call__，实例能够像函数一样对象()调用

class Car:
    def __call__(price):
        print(price)
c=Car()
c(10000)

六、方法特性

1. 无重载：同名方法后定义覆盖前面

2. 动态绑定：运行时新增/替换类的方法

def play(self):pass
Student.play = play

七、封装（私有成员）

• __xxx双下划线：私有，实际改名_类名__xxx，外部可强行实例._类名__属性访问

• _xxx单下划线：保护成员

• __xxx__：系统内置魔法方法

class Emp:
    __money = 1000
e=Emp()
print(e._Emp__money)

八、@property属性装饰器

@property获取值、@xxx.setter修改值，用于数据校验

class Emp:
    def __init__(self,sal):
        self.__sal = sal
    @property
    def salary(self):
        return self.__sal
    @salary.setter
    def salary(self,val):
        if 0<val<100000:
            self.__sal = val
        else:
            print("数值非法")

九、None补充

1. None是NoneType，全局唯 一，地址固定

2. None≠0、False、空字符串、空容器；None == 任意数据 → False

十、课后作业（原题+完整代码答案）

作业1

题目：对下方代码进行内存图文文字解析

class Student:
    company = "尚学堂" #类属性
    count = 0 #类属性
    def __init__(self,name,score):
        self.name = name #实例属性
        self.score = score
        Student.count = Student.count+1
    def say_score(self):
        print("我的公司是:",Student.company)
        print(self.name,'的分数是:',self.score)
s1 = Student('高淇',80)
s1.say_score()
print('一共创建{0}个对象'.format(Student.count))

内存文字解析

1. 执行class Student：堆中创建类对象，存储类属性company、count、方法代码，存放在type空间；

2. s1 = Student('高淇',80)：在堆开辟实例内存，自动执行__init__，生成实例属性name="高淇"、score=80，类属性count自增变为1；

3. 实例s1存在栈中，指向堆实例；方法代码全类共用，实例不单独存储方法；

4. s1.say_score()：通过self访问自身实例属性，通过类名访问共享类属性company；

5. Student.count是全局共享类变量，统计实例总数。

作业2

题目：设计矩形类MyRectangle
(1)属性：左上角坐标x、y；宽width、高height
(2)构造方法：x,y不传默认0，width、height不传默认100
(3)getArea()：计算返回面积
(4)getPerimeter()：计算返回周长
(5)draw()：turtle绘制矩形

import turtle
class MyRectangle:
    #构造方法，设置默认参数
    def __init__(self,x=0,y=0,width=100,height=100):
        self.x = x
        self.y = y
        self.width = width
        self.height = height
    #获取面积
    def getArea(self):
        return self.width * self.height
    #获取周长
    def getPerimeter(self):
        return 2*(self.width + self.height)
    #海龟绘图
    def draw(self):
        pen = turtle.Turtle()
        pen.penup()
        pen.goto(self.x,self.y)
        pen.pendown()
        #循环绘制四条边
        for _ in range(2):
            pen.forward(self.width)
            pen.left(90)
            pen.forward(self.height)
            pen.left(90)
        turtle.done()

#测试代码
if __name__ == "__main__":
    rect = MyRectangle(20,20,250,150)
    print("矩形面积：",rect.getArea())
    print("矩形周长：",rect.getPerimeter())
    # rect.draw() #取消注释运行绘图